| Matching Statements |
| File1 Line# |
File2 Line# |
Statement |
| 1 | 1 | DECLARE FDOS LITERALLY |
| 8 | 8 | FDOS: DECLARE BOOT LITERALLY |
| 14 | 14 | DECLARE BASE LITERALLY |
| 52 | 52 | DISKMON: PROCEDURE(FUNC,INFO) ADDRESS |
| 53 | 53 | DECLARE COPYRIGHT DATA( |
| 56 | 56 | DECLARE FUNC BYTE, |
| 57 | 57 | LINFO BYTE, |
| 58 | 58 | INFO ADDRESS, |
| 59 | 59 | ARET ADDRESS, RET BYTE |
| 96 | 96 | EQU LITERALLY , |
| 97 | 97 | BOOTF EQU , |
| 98 | 98 | PROOT EQU , |
| 99 | 99 | CONSF EQU , |
| 100 | 100 | CONIF EQU , |
| 101 | 101 | CONOF EQU , |
| 102 | 102 | LISTF EQU , |
| 103 | 103 | PUNF EQU , |
| 104 | 104 | READF EQU , |
| 105 | 105 | HOMF EQU , |
| 106 | 106 | SELF EQU , |
| 107 | 107 | TRKF EQU , |
| 108 | 108 | SECF EQU , |
| 109 | 109 | DMAF EQU , |
| 110 | 110 | DRDF EQU , |
| 111 | 111 | DWRF EQU |
| 113 | 113 | DECLARE TRUE LITERALLY , |
| 114 | 114 | FALSE LITERALLY |
| 116 | 116 | DECLARE CHAR$RDY BYTE INITIAL(FALSE), |
| 117 | 117 | KB$CHAR BYTE, |
| 118 | 118 | LISTCOPY BYTE |
| 120 | 120 | CONRDY: PROCEDURE BYTE |
| 122 | 122 | GO TO CONSF |
| 123 | 123 | END CONRDY |
| 125 | 125 | CONIN: PROCEDURE BYTE |
| 127 | 127 | IF CHAR$RDY THEN |
| 128 | 128 | CHAR$RDY = FALSE |
| 128 | 128 | RETURN KB$CHAR |
| 131 | 131 | GO TO CONIF |
| 132 | 132 | END CONIN |
| 134 | 134 | CONBRK: PROCEDURE BYTE |
135
466 | 135
466 | DECLARE CTLC LITERALLY |
| 136 | 136 | DECLARE CTLS LITERALLY |
| 137 | 137 | IF CHAR$RDY THEN RETURN TRUE |
| 138 | 138 | IF CONRDY THEN |
| 140 | 140 | IF (KB$CHAR:= CONIN) = CTLS THEN |
| 141 | 141 | IF CONIN = CTLC THEN GO TO SOOT |
142
146 | 142
146 | RETURN FALSE |
| 144 | 144 | RETURN (CHAR$RDY:= TRUE) |
| 147 | 147 | END CONBRK |
| 149 | 149 | CONCHAR: PROCEDURE(CHAR) |
150
155
163
168 | 150
155
163
168 | DECLARE CHAR BYTE |
| 151 | 151 | GO TO CONCF |
| 152 | 152 | END CONCHAR |
| 154 | 154 | CONOUT: PROCEDURE(CHAR) |
| 157 | 157 | IF CONBRK THEN |
| 159 | 159 | CALL CONCHAR(CHAR) |
| 160 | 160 | END CONOUT |
| 162 | 162 | LSTOUT: PROCEDURE(CHAR) |
| 164 | 164 | GO TO LISTF |
| 165 | 165 | END LSTOUT |
| 167 | 167 | ^PUNOUT: PROCEDURE(CHAR) |
| 169 | 169 | GO TO PUNF |
| 170 | 170 | END PUNOUT |
| 172 | 172 | READIN: PROCEDURE BYTE |
| 173 | 173 | GO TO READF |
| 174 | 174 | END READIN |
| 176 | 176 | TRACK0: PROCEDURE |
| 177 | 177 | GO TO HOMF |
| 178 | 178 | END TRACK0 |
| 180 | 180 | SELDISK: PROCEDURE(DISK) |
| 181 | 181 | DECLARE DISK BYTE |
| 182 | 182 | GO TO SELF |
| 183 | 183 | END SELDISK |
| 185 | 185 | SELTRK: PROCEDURE(TRACK) |
| 186 | 186 | DECLARE TRACK BYTE |
| 187 | 187 | GO TO TRKF |
| 188 | 188 | END SELTRK |
| 190 | 190 | SELSEC: PROCEDURE(SECTOR) |
| 191 | 191 | DECLARE SECTOR BYTE |
| 192 | 192 | GO TO SECF |
| 193 | 193 | END SELSEC |
| 195 | 195 | READ$DISK: PROCEDURE BYTE |
| 196 | 196 | GO TO DRDF |
| 197 | 197 | END READ$DISK |
| 199 | 199 | WRITE$DISK: PROCEDURE BYTE |
| 200 | 200 | GO TO DWRF |
| 201 | 201 | END WRITE$DISK |
| 207 | 207 | ALT EQU , |
| 208 | 208 | ESC EQU , |
| 209 | 209 | TAB EQU , |
| 210 | 210 | BEL EQU , |
| 211 | 211 | LF EQU , |
| 212 | 212 | CR EQU |
| 214 | 214 | DECLARE COLUMN BYTE INITIAL(0), |
| 216 | 216 | DECLARE IOSTATA ADDRESS INITIAL(3), |
| 217 | 217 | IOSTAT BASED IOSTATA BYTE |
| 241 | 241 | TABOUT: PROCEDURE(CHAR) |
| 242 | 242 | DECLARE (I, CHAR) BYTE |
| 243 | 243 | I = (CHAR = TAB AND (7 - (COLUMN AND 7))) |
| 244 | 244 | IF CHAR = TAB THEN CHAR = |
| 245 | 245 | DO WHILE (I:= I - 1) <> 254 |
| 246 | 246 | IF CHAR = CR THEN COLUMN = 0 |
| 247 | 247 | IF CHAR >= THEN COLUMN=COLUMN+1 |
| 248 | 248 | CALL CONOUT(CHAR) |
| 249 | 249 | IF LISTCOPY THEN CALL LSTOUT(CHAR) |
| 251 | 251 | END TABOUT |
| 254 | 254 | CRLF: PROCEDURE |
255
313 | 255
313 | CALL TABOUT(CR) |
| 256 | 256 | CALL TABOUT(LF) |
| 257 | 257 | END CRLF |
| 259 | 259 | PRINT: PROCEDURE(A) |
| 260 | 260 | DECLARE A ADDRESS, (I, M BASED A) BYTE |
| 263 | 263 | DO WHILE (I:=M) <> CALL TABOUT(I) |
| 264 | 264 | A = A + 1 |
| 266 | 266 | END PRINT |
| 268 | 268 | READ: PROCEDURE |
| 276 | 276 | SLASH EQU , |
| 277 | 277 | CTLC EQU , |
| 278 | 278 | CTLU EQU , |
| 279 | 279 | CTL EQU , |
| 280 | 280 | CTLE EQU , |
| 281 | 281 | CTLP EQU , |
| 282 | 282 | CTLZ EQU , |
| 283 | 283 | CTLL EQU |
| 291 | 291 | DECLARE MAXL BASED INFO BYTE, |
| 292 | 292 | COMLEN BYTE, |
| 293 | 293 | BUFFER BASED INFO BYTE, |
| 294 | 294 | C BYTE |
| 296 | 296 | CTLOUT: PROCEDURE |
| 298 | 298 | CALL TABOUT(CTL) |
| 298 | 298 | CALL TABOUT(C OR 40H) |
| 299 | 299 | END CTLOUT |
| 301 | 301 | COMLEN = 0 |
| 302 | 302 | DO WHILE COMLEN < MAXL |
| 304 | 304 | IF (C := CONIN) = CTLC THEN |
305
317
326 | 305
317
326 | CALL CTLOUT |
305
309
317
472
477
819
820 | 305
309
317
472
477
819
820 | CALL CRLF |
306
820
878 | 306
820
878 | GO TO BOOT |
| 308 | 308 | IF C = CTLE THEN |
| 310 | 310 | IF C = CTLP THEN LISTCOPY = NOT LISTCOPY |
| 311 | 311 | IF C = CR THEN |
| 312 | 312 | BUFFER(1) = COMLEN |
| 316 | 316 | IF C = CTLU THEN |
| 317 | 317 | COMLEN=B |
| 319 | 319 | IF C = 7FH THEN |
| 321 | 321 | IF COMLEN > 0 THEN |
| 322 | 322 | CALL TABOUT(BUFFER((COMLEN = COMLEN-1)+2)) |
| 325 | 325 | IF (C AND 01100000B) = 0 THEN |
| 327 | 327 | IF C = TAB THEN CALL TABOUT(TAB) |
| 328 | 328 | CALL TABOUT(C) |
| 329 | 329 | BUFFER((COMLEN := COMLEN+1)+1) = C |
| 332 | 332 | END READ |
| 334 | 334 | DECLARE MAXDSK EQU , |
| 335 | 335 | NDISK EQU |
| 337 | 337 | DECLARE (DPTR, DCNT) BYTE, |
| 338 | 338 | BUFFA ADDRESS INITIAL(60H), |
| 339 | 339 | BUFF BASED BUFFA (128) BYTE |
| 341 | 341 | DECLARE DMX EQU , |
| 345 | 345 | OFFSET EQU , |
| 347 | 347 | AL1 EQU , |
| 353 | 353 | ALLOC0 (32) BYTE, |
| 354 | 354 | ALLOC1 (32) BYTE, |
| 355 | 355 | ALLOCA ADDRESS, |
| 356 | 356 | ALLOC BASED ALLOCA (32) BYTE |
| 359 | 359 | EMP EQU , |
| 361 | 361 | MRD EQU MB , |
| 363 | 363 | FOREVER EQU , |
| 364 | 364 | MAL EQU , |
| 365 | 365 | MRC EQU , |
| 366 | 366 | DSF EQU , |
| 368 | 368 | DMK EQU , |
| 369 | 369 | FLN EQU , |
| 370 | 370 | FSL EQU , |
| 372 | 372 | FDM EQU , |
| 373 | 373 | FRL EQU , |
| 374 | 374 | FRC EQU , |
| 376 | 376 | FRE EQU , |
| 377 | 377 | LFB EQU , |
| 378 | 378 | FNM EQU |
| 380 | 380 | DECLARE S BASED INFO (33) BYTE |
| 411 | 411 | OLDDSK BYTE, |
| 412 | 412 | FCBDSK BYTE, |
| 413 | 413 | CURDSK BYTE INITIAL(0), |
| 414 | 414 | DLOG BYTE INITIAL(0), |
| 415 | 415 | CURTRKV (NDISK) BYTE, |
| 416 | 416 | CURRECV (NDISK) ADDRESS, |
| 417 | 417 | CURTRKA ADDRESS, |
| 418 | 418 | CURRECA ADDRESS, |
| 419 | 419 | CURREC BASED CURRECA ADDRESS, |
| 420 | 420 | CUPTRK BASED CURTRKA BYTE, |
| 421 | 421 | RCOUNT BYTE, |
| 423 | 423 | VRECORD BYTE, |
| 424 | 424 | ARECORD ADDRESS |
| 426 | 426 | PDISK: PROCEDURE |
427
472
819 | 427
472
819 | CALL PRINT(. ) |
| 428 | 428 | CALL TABOUT( +CURDSK) |
| 429 | 429 | END PDISK |
| 431 | 431 | HOME: PROCEDURE |
| 433 | 433 | CALL TRACK0 |
| 434 | 434 | CALL SELTRK(OFFSET) |
| 435 | 435 | CURREC, CURTRK = 0 |
| 436 | 436 | END HOME |
| 438 | 438 | SEEK: PROCEDURE |
| 440 | 440 | DECLARE TRAN, DATA |
| 441 | 441 | (01H,07H,0DH,13H, 19H, 05H, 0BH, 11H, 17H, 03H, 09H, 0FH, |
| 442 | 442 | 15H,02H,08H,BEH, 14H, 1AH, 06H, BCH, 12H, 18H, 04H, 0AH, |
| 443 | 443 | 10H,16H) |
| 445 | 445 | DECLARE T ADDRESS |
| 447 | 447 | DO WHILE ARECORD < CURREC |
| 448 | 448 | CURREC = CURREC - 26 |
| 449 | 449 | CURTRK = CURTRK - 1 |
| 451 | 451 | DO WHILE ARECORD >= (T := CURREC + 26) |
| 452 | 452 | CURREC = T |
| 453 | 453 | CURTRK = CURTRK + 1 |
| 459 | 459 | CALL SELTRK(CURTRK+OFFSET) |
| 460 | 460 | CALL SELSEC(TRAN(ARECORD - CURREC)) |
| 461 | 461 | END SEEK |
| 463 | 463 | WAITIO: PROCEDURE(READING) |
464
724 | 464
724 | DECLARE READING BYTE |
| 465 | 465 | DECLARE COND BYTE |
| 467 | 467 | IF READING THEN COND = READ$DISK |
| 468 | 468 | COND = WRITE$DISK |
| 469 | 469 | IF COND = 0 THEN RETURN |
473
820 | 473
820 | CALL PDISK |
| 473 | 473 | IF CONIN = CTLC THEN GO TO BOOT |
| 476 | 476 | IF (IOSTAT AND 11B) > 1 THEN HALT |
| 478 | 478 | END WAITIO |
| 480 | 480 | RDBUFF: PROCEDURE |
| 482 | 482 | CALL WAITIO(TRUE) |
| 483 | 483 | END RDBUFF |
| 485 | 485 | WRBUFF: PROCEDURE |
| 487 | 487 | CALL WAITIO(FALSE) |
| 488 | 488 | END WRBUFF |
| 490 | 490 | INDEX: PROCEDURE |
| 493 | 493 | ARECORD = S(FDM+SHR(VRECORD, 3)) |
| 494 | 494 | END INDEX |
| 496 | 496 | ATRAN: PROCEDURE |
| 499 | 499 | ARECORD = SHL(ARECORD, 3) OR (VRECORD AND 111B) |
| 500 | 500 | END ATRAN |
| 502 | 502 | GETFCB: PROCEDURE |
| 504 | 504 | VRECORD = S(FRL) |
| 505 | 505 | RCOUNT = S(FRC) |
| 506 | 506 | END GETFCB |
| 508 | 508 | SETFCB: PROCEDURE |
| 511 | 511 | S(FRL) = VRECORD + 1 |
| 512 | 512 | S(FRC) = RCOUNT |
| 513 | 513 | END SETFCB |
| 515 | 515 | SEEK$DIR: PROCEDURE |
| 517 | 517 | ARECORD = SHR(DCRT, DSF) |
518
761
795 | 518
761
795 | CALL SEEK |
| 519 | 519 | END SEEK$DIR |
| 521 | 521 | READ$DIR: PROCEDURE |
| 523 | 523 | IF (DCNT:=DCNT+1) > DMX THEN |
524
584
622 | 524
584
622 | DCNT = 255 |
| 526 | 526 | IF (DPTR:=SHL(DCNT AND DMK, FSL)) = 0 THEN |
527
664 | 527
664 | CALL SEEK$DIR |
528
763 | 528
763 | CALL RDBUFF |
| 530 | 530 | END READ$DIR |
| 532 | 532 | GET$ALLOC: PROCEDURE(I) BYTE |
533
544
556
577
688 | 533
544
556
577
688 | DECLARE I BYTE |
| 534 | 534 | RETURN ALLOC(I) |
| 535 | 535 | END GET$ALLOC |
| 537 | 537 | PUT$ALLOC: PROCEDURE(I,X) |
538
561 | 538
561 | DECLARE (I, X) BYTE |
| 539 | 539 | ALLOC(I) = X |
| 540 | 540 | END PUT$ALLOC |
| 542 | 542 | GET$ALLOC$BIT: PROCEDURE(I) BYTE |
| 545 | 545 | RETURN ROL(ALLOC(SHR(I, 3)), (I AND 1118) |
| 546 | 546 | END GET$ALLOC$BIT |
| 548 | 548 | SET$ALLOC$BIT: PROCEDURE(I,B) |
| 550 | 550 | DECLARE (I, B) BYTE |
| 551 | 551 | CALL PUT$ALLOC(SHR(I, 3) |
| 552 | 552 | ROR((GET$ALLOC$BIT(I) AND 0FEH) OR B, (I AND 111B) + 1)) |
| 553 | 553 | END SET$ALLOC$SIT |
| 555 | 555 | GETBUFF: PROCEDURE(I) BYTE |
| 557 | 557 | RETURN BUFF(I) |
| 558 | 558 | END GETBUFF |
| 560 | 560 | PUTBUFF: PROCEDURE(I,X) |
| 562 | 562 | BUFF(I) = X |
| 563 | 563 | END PUTBUFF |
| 565 | 565 | SCANDM: PROCEDURE(BIT) |
| 566 | 566 | DECLARE (BIT, I, K) BYTE |
| 570 | 570 | DO I = DPTR+FDM TO DPTR+LFB |
| 571 | 571 | IF (K:= GETBUFF(I)) <> 0 THEN |
| 572 | 572 | CALL SET$ALLOC$BIT(K, BIT) |
| 574 | 574 | END SCANDM |
| 576 | 576 | INITIALIZE: PROCEDURE |
| 579 | 579 | RET = FALSE |
| 580 | 580 | ALLOC = AL1 |
| 581 | 581 | DO I=1 TO 31 |
| 581 | 581 | CALL PUT$ALLOC(I,0) |
583
623 | 583
623 | CALL HOME |
585
605
632 | 585
605
632 | DO FOREVER |
586
606 | 586
606 | CALL READ$DIR |
587
633
729 | 587
633
729 | IF DCNT = 255 THEN RETURN |
| 588 | 588 | IF GETBUFF(DPTR) <> EMP THEN |
| 590 | 590 | RET = RET OR GETBUFF(DPTR+1) = |
| 592 | 592 | CALL SCANDM(1) |
| 595 | 595 | END INITIALIZE |
| 597 | 597 | DECLARE SEARCHL BYTE |
| 598 | 598 | SEARCHA ADDRESS |
| 600 | 600 | SEARCHN: PROCEDURE |
| 603 | 603 | DECLARE (I, C) BYTE |
604
928 | 604
928 | INFO = SEARCHA |
| 607 | 607 | IF (RET := DCNT) = 255 THEN RETURN |
608
782 | 608
782 | I = 0 |
| 609 | 609 | DO WHILE (I ( SEARCHL) AND |
| 611 | 611 | ((C := S(I)) = GETBUFF (DPTR+I) OR C = 63) |
| 612 | 612 | I = I + 1 |
| 614 | 614 | IF I = SEARCHL THEN RETURN |
| 616 | 616 | END SEARCHN |
| 618 | 618 | SEARCH: PROCEDURE(XL) |
| 619 | 619 | DECLARE XL BYTE |
| 620 | 620 | SEARCHL = XL |
| 621 | 621 | SEARCHA = INFO |
625
639
683
929 | 625
639
683
929 | CALL SEARCHN |
| 626 | 626 | END SEARCH |
| 628 | 628 | DELETE: PROCEDURE |
| 629 | 629 | DECLARE (I, J, K) BYTE |
631
681 | 631
681 | CALL SEARCH(FRE) |
| 635 | 635 | CALL SCANDM(0) |
| 636 | 636 | CALL PUTBUFF(DPTR, EMP) |
638
665
796 | 638
665
796 | CALL WRBUFF |
| 641 | 641 | END DELETE |
| 643 | 643 | GET$BLOCK: PROCEDURE(L) BYTE |
| 646 | 646 | DECLARE (L, R) BYTE |
| 647 | 647 | R = L |
| 648 | 648 | DO WHILE (R < MAL) OR (L > 0) |
| 649 | 649 | L = L - (1 AND L > 0) |
| 650 | 650 | R = R + (1 AND R < MAL) |
| 651 | 651 | IF NOT GET$ALLOC$BIT(R) THEN RETURN R |
| 652 | 652 | IF NOT GET$ALLOC$BIT(L) THEN RETURN L |
| 654 | 654 | RETURN 0 |
| 655 | 655 | END GET$BLOCK |
| 657 | 657 | COPY$DIR: PROCEDURE(B,L) |
| 658 | 658 | DECLARE (B, L) BYTE |
| 661 | 661 | DO WHILE (L:=L-1) <> 255 |
| 662 | 662 | CALL PUTBUFF(L+DPTR, S(B+L)) |
| 666 | 666 | END COPY$DIR |
| 668 | 668 | COPY$FCB: PROCEDURE |
| 670 | 670 | CALL COPY$DIR(O, FRL) |
| 671 | 671 | END COPY$FCB |
| 673 | 673 | RENAME: PROCEDURE |
| 682 | 682 | DO WHILE DCNT <> 255 |
| 682 | 682 | CALL COPY$DIR(FDM,FRE) |
| 685 | 685 | END RENAME |
| 687 | 687 | OPEN: PROCEDURE |
690
699
732
925 | 690
699
732
925 | CALL SEARCH(FNM) |
691
700
712 | 691
700
712 | IF DCNT <> 255 THEN |
692
715 | 692
715 | DO I = FNM TO LFB |
| 693 | 693 | S(I) = GETBUFF(DPTR+I) |
| 695 | 695 | END OPEN |
| 697 | 697 | CLOSE: PROCEDURE |
701
719 | 701
719 | CALL COPY$FCB |
| 702 | 702 | END CLOSE |
| 704 | 704 | MAKE: PROCEDURE |
| 707 | 707 | DECLARE I BYTE, |
| 708 | 708 | FCB ADDRESS |
| 709 | 709 | FCB = INFO |
| 709 | 709 | INFO = .EMP |
| 711 | 711 | CALL SEARCH(I) |
| 714 | 714 | INFO = FCB |
| 716 | 716 | S(I) = 0 |
| 721 | 721 | END MAKE |
| 723 | 723 | OPEN$REEL: PROCEDURE(READING) |
727
921 | 727
921 | CALL CLOSE |
| 731 | 731 | S(FRE) = S(FRE) + 1 |
733
738 | 733
738 | IF DCNT = 255 THEN |
| 734 | 734 | IF READING THEN RETURN |
735
945 | 735
945 | CALL MAKE |
737
917 | 737
917 | CALL OPEN |
739
750
775 | 739
750
775 | RET = 1 |
742
747
772 | 742
747
772 | CALL GETFCB |
743
807 | 743
807 | RET = 0 |
| 744 | 744 | END OPEN$REEL |
| 746 | 746 | DISKREAD: PROCEDURE |
| 749 | 749 | IF RCOUNT <= VRECORD THEN |
| 751 | 751 | IF VRECORD = 128 THEN CALL OPEN$REEL(TRUE) |
| 752 | 752 | VRECORD = 0 |
| 753 | 753 | IF RET <> 0 THEN RETURN |
755
776 | 755
776 | CALL INDEX |
| 758 | 758 | IF LOW(ARECORD) = 0 THEN RET = 1 |
759
794 | 759
794 | CALL ATRAN |
764
803
809 | 764
803
809 | CALL SETFCB |
| 767 | 767 | END DISKREAD |
| 770 | 770 | DISKWRITE: PROCEDURE |
| 771 | 771 | DECLARE (I L) BYTE |
| 774 | 774 | IF VRECORD > MRG THEN |
| 777 | 777 | IF LOW (ARECORD) = 0 THEN |
| 783 | 783 | IF (L := FDM + SHR(VRECORD, 3)) > FDM THEN |
| 784 | 784 | I = S(L=1) |
| 785 | 785 | IF (I = GET$BLOCK(I)) = 0 THEN |
| 786 | 786 | RET = 2 |
| 787 | 787 | CALL SET$ALLOC$BIT(I,1) |
| 789 | 789 | ARECORD, S(L) = 1 |
| 793 | 793 | IF RET = 0 THEN |
| 797 | 797 | IF RCOUNT <= VRECORD THEN RCOUNT = VRECORD +1 |
| 800 | 800 | IF VRECORD = MRC THEN |
| 803 | 803 | CALL OPENREEL(FALSE) |
| 806 | 806 | IF RET = 0 THEN VRECORD = 255 |
| 812 | 812 | END DISKWRITE |
| 814 | 814 | SELECT: PROCEDURE |
| 818 | 818 | IF CURDSK > MAXDSK THEN |
| 822 | 822 | ALLOCA = .ALLOC0(SHL(CURDSK, 5)) |
| 827 | 827 | CURTRKA = .CURTRKV(CURDSK) |
| 829 | 829 | CURRECA = .CURRECV(CURDSK) |
| 832 | 832 | CALL SELDISK(CURDSK) |
| 835 | 835 | IF NOT ROR(ROL(DLOG, 1), CURDSK+1) THEN |
| 837 | 837 | DLOG = DLOG OR ROR(ROL(1, CURDSK+1), 1) |
| 838 | 838 | CALL INITIALIZE |
| 840 | 840 | END SELECT |
| 842 | 842 | CURSELECT: PROCEDURE |
| 843 | 843 | IF LINFO <> CURDSK THEN |
| 844 | 844 | CURDSK = LINFO |
844
910 | 844
910 | CALL SELECT |
| 846 | 846 | END CURSELECT |
| 848 | 848 | RESELECT: PROCEDURE |
| 850 | 850 | IF (LINFO := (S AND 1$1111B) -1) < 30 THEN |
| 851 | 851 | OLDDSK = CURDSK |
| 851 | 851 | FCBDSK = S |
| 851 | 851 | S = S AND 1110*0000B |
852
914
963 | 852
914
963 | CALL CURSELECT |
| 854 | 854 | END RESELECT |
| 856 | 856 | SETDMA: PROCEDURE(A) |
| 857 | 857 | DECLARE A ADDRESS |
| 858 | 858 | CALL SELDMA(BUFFA.= A) |
| 859 | 859 | END SETDMA |
| 865 | 865 | DECLARE STACK (16) ADDRESS, |
| 866 | 866 | OLDSP ADDRESS |
| 868 | 868 | OLDSP = STACKPTR |
| 869 | 869 | STACKPTR = STACK(LENGTH(STACK)) |
| 872 | 872 | LINFO = LOW(INFO) |
| 873 | 873 | ARET, RET = 0 |
| 874 | 874 | FCBDSK = 0 |
| 876 | 876 | DO CASE FUNC |
| 881 | 881 | IF ((RET := CONIN) >= ) OR |
| 882 | 882 | (RET = CR) OR (RET = LF) OR (RET = TAS) THEN |
| 883 | 883 | CALL TABOUT(RET) |
| 886 | 886 | CALL TABOUT(LINFO) |
| 888 | 888 | RET = READIN |
| 890 | 890 | CALL PUNOUT(LINFO) |
| 892 | 892 | CALL LSTOUT(LINFO) |
| 894 | 894 | ARET = FDOS |
| 896 | 896 | ARET = IOSTAT |
| 898 | 898 | IOSTAT = INFO |
| 900 | 900 | CALL PRINT(INFO) |
| 902 | 902 | CALL READ |
| 904 | 904 | RET = CONBRK |
| 908 | 908 | CURDSK,D LOG = 0 |
| 909 | 909 | CALL SETDMA(80H) |
| 911 | 911 | CHAR$RDY, LISTCOPY = FALSE |
916
920
924
928
932
936
940
944
948 | 916
920
924
928
932
936
940
944
948 | CALL RESELECT |
| 933 | 933 | CALL DELETE |
| 937 | 937 | CALL DISKREAD |
| 941 | 941 | CALL DISKWRITE |
| 949 | 949 | CALL RENAME |
| 952 | 952 | RET = DLOG |
| 954 | 954 | RET = CURDSK |
| 956 | 956 | CALL SETDMA(INFO) |
| 958 | 958 | ARET = ALLOCA |
| 961 | 961 | GOBACK: |
| 962 | 962 | IF FCBDSK <> 0 THEN |
| 963 | 963 | S = FCBDSK |
| 963 | 963 | LINFO = OLDDSK |
| 966 | 966 | STACKPTR = OLDSP |
| 969 | 969 | RETURN ARET OR RET |
| 970 | 970 | END DISKMON |
| 972 | 972 | DECLARE TEMPDATA(10) BYTE |
| Matching Comments and Strings |
| File1 Line# |
File2 Line# |
Comment/String |
| 1 | 1 | 3200H |
| 2 | 2 | CP/M BDOS |
| 3 | 3 | COPYRIGHT (C) 1976 |
| 4 | 4 | DIGITAL RESEARCH |
| 5 | 5 | BOX 579, PACIFIC GROVE |
| 6 | 6 | CALIFORNIA, 93950 |
| 8 | 8 | WBOOT |
| 11 | 11 | C P / M B A S I C I / O S Y S T E M (B I O S) |
| 14 | 14 | 3B00H |
| 14 | 14 | DISK INTERFACE AND CONSOLE IO |
| 15 | 15 | THE FOLLOWING SUBROUTINES ARE ASSUMED TO EXIST, |
| 16 | 16 | STARTING AT THE ADDRESS 'BASE' |
| 18 | 18 | BASE BOOT SYSTEM REBOOT OPERATION |
| 19 | 19 | BASE+3 WBOOT SYSTEM REBOOT - WARM START |
| 20 | 20 | BASE+6 CONSTAT CONSOLE STATUS - RETURNS |
| 21 | 21 | 0 IN REG-A IF NO CONSOLE DATA READY |
| 22 | 22 | FF IF CHARACTER IS READY |
| 23 | 23 | BASE+9 CONIN CONSOLE CHARACTER INTO ACCUMULATOR - 0 PARITY |
| 24 | 24 | BASE+12 CONOUT CONSOLE CHARACTER SENT FROM REGISTER C |
| 25 | 25 | BASE+15 LIST SEND CHARACTER FROM REGISTER C TO LIST DEVICE |
| 26 | 26 | BASE+18 PUNCH SEND CHARACTER FROM REGISTER C TO PUNCH DEVICE |
| 27 | 27 | BASE+21 READER READ CHARACTER TO REGISTER A WITH 0 PARITY |
| 28 | 28 | BASE+24 HOME MOVE DISK HEAD TO TRACK 0 |
| 29 | 29 | BASE+27 SELDSK SELECT DISK DRIVE GIVEN BY REGISTER C (0, 1, ..) |
| 30 | 30 | BASE+30 SETTRK SET TRACK (0-76) GIVEN BY REGISTER C |
| 31 | 31 | BASE+33 SETSEC SET SECTOR NUMBER GIVEN BY REG C (1-26) |
| 32 | 32 | BASE+36 SETDMA SET DMA ADDRESS GIVEN BY REG PAIR B, C (INITIALLY |
| 33 | 33 | DEFAULTED TO 86H) |
| 34 | 34 | BASE+39 READ READ DISK SECTOR (SETTRK, SETSEC, SELDSK ASSUMED) |
| 35 | 35 | ERROR RETURNS IN REGISTER A IN THREE |
| 36 | 36 | LEAST SIGNIFICANT BITS (2, 1, AND 0) |
| 37 | 37 | BIT ERROR |
| 38 | 38 | 0 HARDWARE MALFUNCTION |
| 39 | 39 | 1 DRIVE NOT READY |
| 40 | 40 | 2 COMMAND SEQUENCE ERROR |
| 41 | 41 | BASE+42 WRITE WRITE DISK SECTOR (SETTRK...SELDSK ASSUMED) |
| 42 | 42 | ERROR RETURNS IN REGISTER A AS ABOVE |
| 44 | 44 | CP/M ALSO PROVIDES A TEN BYTE AREA IMMEDIATELY AHEAD OF THE |
| 45 | 45 | DISK AND CONSOLE INTERFACE FOR TEMPORARY STORAGE IN CASE THE |
| 46 | 46 | INTERFACE IS IMPLEMENTED IN ROM |
| 54 | 54 | COPYRIGHT (C) 1976, DIGITAL RESEARCH |
| 57 | 57 | LOW ORDER INFO |
| 61 | 61 | FUNC IS THE DISK MONITOR FUNCTION NUMBER AS SHOWN BELOW |
| 62 | 62 | 0: SYSTEM RESET |
| 63 | 63 | 1: READ CONSOLE DEVICE |
| 64 | 64 | 2: WRITE CONSOLE DEVICE |
| 65 | 65 | 3: REAL READER DEVICE |
66
889 | 66
889 | 4: WRITE PUNCH DEVICE |
67
891 | 67
891 | 5: WRITE LIST DEVICE |
68
893 | 68
893 | 6: INTERROGATE MEMORY SIZE |
69
895 | 69
895 | 7: INTERROGATE DEVICE STATUS |
70
897 | 70
897 | 8: CHANGE DEVICE STATUS |
| 71 | 71 | 9: PRINT BUFFER ON CONSOLE |
| 72 | 72 | 10: READ BUFFER FROM CONSOLE |
| 73 | 73 | 11: CONSOLE CHARACTER READY |
| 74 | 74 | 12: LIFT HEAD (NO OPERATION ON CPM 16D2JUN75) |
| 75 | 75 | 13: RESET DISK SYSTEM - SELECT DISK 0 |
76
913 | 76
913 | 14: SELECT DISK 'INFO' |
| 77 | 77 | 15: OPEN FILE |
| 78 | 78 | 16: CLOSE FILE |
| 79 | 79 | 17: SEARCH FOR FIRST OCCURRENCE |
| 80 | 80 | 18: SEARCH FOR NEXT OCCURRENCE |
81
931 | 81
931 | 19: DELETE A FILE |
82
935 | 82
935 | 20: READ A FILE |
83
939 | 83
939 | 21: WRITE A FILE |
84
943 | 84
943 | 22: CREATE A FILE |
85
947 | 85
947 | 23: RENAME A FILE |
| 86 | 86 | 24: RETURN LOGIN VECTOR - EACH BIT CORRESPONDS TO |
| 87 | 87 | A DISK NUMBER, FROM LSB TO MSB. 1 INDICATES |
| 88 | 88 | THE DISK IS LOGGED IN. |
| 89 | 89 | 25: RETURN CURRENTLY SELECTED DISK NUMBER |
| 90 | 90 | 26: SET SUBSEQUENT DMA ADDRESS |
| 91 | 91 | 27: RETURN BASE ADDRESS OF ALLOCATION VECTOR |
| 92 | 92 | (USED TO DETERMINE REMAINING SPACE) |
| 96 | 96 | LITERALLY |
| 97 | 97 | 3E$00H |
| 98 | 98 | 3E$03H |
| 99 | 99 | 3E$06H |
| 100 | 100 | 3E$09H |
| 101 | 101 | 3E$0CH |
| 102 | 102 | 3E$0FH |
| 103 | 103 | 3E$12H |
| 104 | 104 | 3E$15H |
| 105 | 105 | 3E$19H |
| 106 | 106 | 3E$1BH |
| 107 | 107 | 3E$1EH |
| 108 | 108 | 3E$21H |
| 109 | 109 | 3E$24H |
| 110 | 110 | 3E$27H |
| 111 | 111 | 3E$2AH |
| 116 | 116 | TRUE IF CHAR READ |
| 117 | 117 | VALUE OF CHARACTER WHEN CHAR$RDY IS TRUE |
| 118 | 118 | TRUE IF COPYING TO LIST DEVICE |
| 121 | 121 | RETURN TRUE IF CHAR READY AT CONSOLE |
| 126 | 126 | READ NEXT CONSOLE CHARACTER |
| 127 | 127 | CHARACTER IS READY |
| 130 | 130 | OTHERWISE READ THE CHARACTER |
135
277
466 | 135
277
466 | 03H |
| 136 | 136 | 13H |
| 137 | 137 | CHARACTER ALREADY READ |
| 138 | 138 | CHECK FOR TYPE TERMINATION FUNCTION |
| 140 | 140 | STOP TYPE |
| 156 | 156 | CHECK FOR BREAK CHARACTER |
| 158 | 158 | SEND CONSOLE CHARACTER |
| 203 | 203 | CONSOLE COMMUNICATION PROCEDURES |
| 206 | 206 | SPECIAL CHARACTERS |
| 207 | 207 | 7DH |
| 208 | 208 | 1BH |
| 209 | 209 | 0SH |
| 210 | 210 | 07H |
| 214 | 214 | CURRENT CONSOLE COLUMN |
| 216 | 216 | IO STATUS BYTE LOCATION |
| 217 | 217 | VALUE OF STATUS BYTE |
| 218 | 218 | IOSTAT DEFINES THE CURRENT DEVICE ASSIGNMENT |
| 219 | 219 | 0-1 CONSOLE |
220
225
230
235 | 220
225
230
235 | 0 TTY |
221
236 | 221
236 | 1 CRT |
| 222 | 222 | 2 BATCH (USE READER DEFINITION) |
| 223 | 223 | 3 USER (1) |
| 224 | 224 | 2-3 READER |
| 226 | 226 | 1 PTR |
227
232
237 | 227
232
237 | 2 USER (1) |
228
233
238 | 228
233
238 | 3 USER (2) |
| 229 | 229 | 4-5 PUNCH |
| 231 | 231 | 1 PTP |
| 234 | 234 | 6-7 LIST |
| 261 | 261 | PRINT THE STRING STARTING AT ADDRESS A UNTIL THE NEXT |
| 262 | 262 | OCCURRENCE OF A DOLLAR SIGN |
| 269 | 269 | READ CHARACTERS FROM THE CONSOLE DEVICE |
| 270 | 270 | INTO THE MEMORY LOCATION GIVEN BY 'INFO', |
| 271 | 271 | UNTIL THE FIRST CARRIAGE RETURN |
| 272 | 272 | IS ENCOUNTERED. ALLOW BACKSPACE (RUBOUT), |
| 273 | 273 | LINE ELIMINATE (CTL U), AND SYSTEM RE-BOOT |
| 274 | 274 | (CTL C) |
| 276 | 276 | 5CH |
| 278 | 278 | 15H |
| 279 | 279 | 5EH |
| 280 | 280 | 05H |
| 281 | 281 | 10H |
| 282 | 282 | 1AH |
| 283 | 283 | 0CH |
| 285 | 285 | THE INFO POINTER IS ASSUMED TO ADDRESS AN |
| 286 | 286 | AREA OF MEMORY CONTAINING TWO BYTE QUANTITIES |
| 287 | 287 | THE FIRST GIVES THE MAXIMUM BUFFER LENGTH, AND |
| 288 | 288 | THE SECOND IS SET TO THE NUMBER OF CHARACTERS |
| 289 | 289 | SCANNED UPON RETURN |
| 291 | 291 | MAX LENGTH |
| 292 | 292 | SCANNED LENGTH |
| 293 | 293 | BUFFER |
| 297 | 297 | PRINT UP-ARROW IN FRONT OF LAST CHARACTER READ |
| 303 | 303 | MAKE ALPHABETICS UPPER CASE |
| 308 | 308 | PHYSICAL RETURN |
| 319 | 319 | RUBOUT |
| 325 | 325 | CONTROL CHARACTER |
| 334 | 334 | MAX DISK NUMBER 0, 1, ... |
| 335 | 335 | NUMBER OF DISKS = MAXDSK+1 |
| 342 | 342 | DMX IS THE LAST DIRECTORY ENTRY NUMBER |
| 343 | 343 | (LISTED AS B, 1, ... , DMX) |
| 345 | 345 | NUMBER OF TRACKS USED BY BOOT |
| 347 | 347 | 0C0H |
| 347 | 347 | FIRST ALLOCATION |
| 348 | 348 | VECTOR ELEMENT, EACH BIT THAT IS '1' RESERVES |
| 349 | 349 | A 1 K BLOCK FOR THE DIRECTORY, EACH BLOCK IS |
| 350 | 350 | 8 RECORDS BY 12S BYTES PER RECORD (NOTE THAT |
| 351 | 351 | RESERVATIONS START ON THE LEFT OF THE WORD |
| 353 | 353 | ALLOCATION VECTOR FOR DISK 0 |
| 354 | 354 | ALLOCATION VECTOR FOR DISK 1 |
| 355 | 355 | POINTER TO CURRENTLY REFERENCED ALLOC |
| 356 | 356 | ALLOC VECTOR TEMPLATE |
| 359 | 359 | 0E5H |
| 361 | 361 | NUMBER OF READ RE-TRYS |
| 363 | 363 | WHILE TRUE |
| 364 | 364 | 242 |
| 364 | 364 | LARGEST BLOCK NUMBER |
| 365 | 365 | 127 |
| 365 | 365 | LARGEST RECORD NUMBER |
| 366 | 366 | AMOUNT TO SHIFT 128 BYTE RECORD |
| 367 | 367 | TO GET A SINGLE DISK ENTRY |
| 368 | 368 | 118 |
| 368 | 368 | MASK CORRESPONDING TO DSF |
| 370 | 370 | AMOUNT TO SHIFT TO MULTIPLY |
| 371 | 371 | BY THE FCB LENGTH (FLN) |
| 372 | 372 | BEGINNING OF DISK MAP |
| 373 | 373 | LOCATION OF REC TO R/W |
| 374 | 374 | LOCATION OF RECORD COUNT |
| 375 | 375 | (MUST BE ONE BELOW DISK MAP) |
| 376 | 376 | POSITION OF REEL NUMBER |
| 378 | 378 | LENGTH OF FILE NAME |
| 380 | 380 | FILE CONTROL BLOCK |
| 381 | 381 | PASSED TO THE DISK MONITOR FROM THE USER |
| 383 | 383 | THE FILE CONTROL BLOCK FORMAT IS SH0WN BELOW: |
384
387 | 384
387 | -------------------------------------------------------- |
| 385 | 385 | / 1 BY / 8 BY / 3 BY / 1 BY /2BY/1 BY/ 16 BY / |
| 386 | 386 | /F1LETYPE/ NAME / EXT / REEL NO/XXX/RCNT/DM0 DM15/ |
| 389 | 389 | FILETYPE : 0E5H IF AVAILABLE (OTHERWISE UNDEFINED NOW) |
| 390 | 390 | NAME : 8 CHARACTER PRIMARY NAME |
| 391 | 391 | EXT : 3 CHARACTER EXTENT |
| 392 | 392 | COM IMPLIES COMMAND TYPE |
| 393 | 393 | (OTHERWISE UNDEFINED NOW) |
| 394 | 394 | REEL NO : 'REEL NUMBER' FIRST REEL IS 0, SECOND IS 1, |
| 395 | 395 | AND SO FORTH UNTIL 255 |
| 396 | 396 | XXX : UNUSED FOR NOW |
| 397 | 397 | RCNT : RECORD COUNT IN FILE (0 TO , 127) |
| 398 | 398 | DM0 ... : DISK ALLOCATION MAP, 255 IF NOT ALLOCATED, |
| 399 | 399 | DM15 OTHERWISE IT POINTS TO ALLOCATED DISK BLOCK |
| 401 | 401 | THE FILE CONTROL BLOCK IS FOLLOWED BY ONE BYTE OF |
| 402 | 402 | INFORMATION WHICH GIVES THE NEXT RECORD , TO BE READ |
| 403 | 403 | OR WRITTEN IN AN OPENED FILE. THIS INFORMATION |
| 404 | 404 | IS NOT A PART OF THE DIRECTORY. EACH READ OR WRITE |
| 405 | 405 | WILL INCREMENT THIS RECORD COUNT. |
| 411 | 411 | DISK ON ENTRY TQ DOS |
| 412 | 412 | DISK NAMED IN FCB |
| 413 | 413 | CURRENTLY ADDRESSED DISK |
| 414 | 414 | BIT VECTOR GIVING LOGGED-IN DISKS |
| 415 | 415 | TRACK VECTOR |
| 416 | 416 | RECORD VECTOR |
| 417 | 417 | POINTS TO CURRENT TRACK NUMBER |
| 418 | 418 | POINTS TO CURRENT RECORD NUMBER |
| 419 | 419 | CURRENTLY ADDRESSED RECORD |
| 420 | 420 | CURRENT TRACK 0-76 |
| 421 | 421 | RECORD COUNT IN CURRENTLY |
| 422 | 422 | ADDRESSED FCB |
| 423 | 423 | CURRENT VIRTUAL RECORD |
| 424 | 424 | CURRENT ACTUAL RECORD |
| 427 | 427 | DISK $ |
| 432 | 432 | MOVE TO HOME POSITION, THEN OFFSET BY DOS TRACKS |
| 433 | 433 | AT HOME POSITION |
| 434 | 434 | SELECT FIRST DIRECTRY POSITION |
| 439 | 439 | SEEK THE TRACK GIVEN BY ARECORD (ACTUAL RECORD) |
| 440 | 440 | SECTOR NUMBER TRANSLATE TABLE |
| 456 | 456 | WE ARE NOW POSITIONED OVER THE TRACK CONTAINING THE ACTUAL |
| 457 | 457 | RECORD. THE SECTOR TO BE READ IS ARECORD - CURREC + 1. THE |
| 458 | 458 | TRACK NUMBER IS CURTRK |
| 464 | 464 | TRUE IF READING, FALSE IF WRITING |
| 465 | 465 | CONDITION UPON RETURN |
| 469 | 469 | DISK I/O SUCCESSFUL |
| 471 | 471 | ARRIVE HERE AFTER TOO MANY READ WRITE FAILURES |
| 472 | 472 | PERM ERR $ |
| 474 | 474 | ENSURE NOT BATCH PROCESSING |
| 481 | 481 | START AN I/O AND WAIT FOR 10 FINISH |
| 486 | 486 | WRITE THE BUFFER, SELECT NON-DELETED DATA |
| 491 | 491 | COMPUTE DISK BLOCK HUMBER FROM CURRENT |
| 492 | 492 | FCB ADDRESSED BY INFO |
| 497 | 497 | COMPUTE ACTUAL TRACK ADDRESS (ASSUMES |
| 498 | 498 | PREVIOUS CALL TO INDEX |
| 503 | 503 | SET VARIABLES FROM CURRENTLY ADDRESSED FCB. |
| 509 | 509 | PLACE VALUES BACK INTO CURRENTLY ADDRESSED |
| 510 | 510 | FCB, AND INCREMENT THE RECORD COUNT |
| 516 | 516 | SEEK THE RECORD CONTAINING THE CURRENT DIRECTORY ENTRY |
| 522 | 522 | READ NEXT DIRECTORY ENTRY (SET DCNT=255 INITIALLY) |
| 543 | 543 | RETURN THE I-TH BIT OF ALLOC |
| 549 | 549 | SET THE I-TH BIT OF ALLOC TO THE LSB OF B |
| 567 | 567 | SCANDM SCANS THE DISK MAP ADDRESSED BY DPTR FOR NON-ZERO ENTRIES |
| 568 | 568 | -- THE ALLOCATION VECTOR ENTRY CORRESPONDING TO A NON-ZERO ENTRY |
| 569 | 569 | IS SET TO THE VALUE OF 'BIT' |
| 578 | 578 | INITIALIZE THE DISK SYSTEM |
| 579 | 579 | SET TO TRUE IF $ FILE EXISTS |
| 589 | 589 | CHECK FOR $ FILE (IN CASE OF SUBMIT) |
| 591 | 591 | SET ALLOC BIT TO 1 FOR EACH NON-ZERO DM ENTRY |
| 597 | 597 | SEARCH LENGTH SET BY SEARCH |
| 598 | 598 | SEARCH ADDRESS SET BY SEARCH |
| 601 | 601 | SEARCH FOR THE NEXT DIRECTORY ELEMENT, ASSUMING A PREVIOUS |
| 602 | 602 | CALL ON SEARCH WHICH SETS SEARCHA AND SEARCHL |
| 610 | 610 | MATCH OR QUESTION MARK |
| 624 | 624 | NOW READY TO READ THE DISK |
| 630 | 630 | SEARCH ONLY UP THROUGH THREE CHARACTER EXTENT |
| 633 | 633 | NO MORE ENTRIES MATCH |
| 634 | 634 | SET EACH NON-ZERO DISK MAP ENTRY TO 0;IN ALLOC VECTOR |
| 637 | 637 | ARECORD HAS BEEN PREVIOUSLY SOUGHT BY READDIR |
| 644 | 644 | FIND A BLOCK WHICH IS AVAILABLE ON THE DISK AND IS CLOSEST |
| 645 | 645 | TO THE BLOCK 'L', RETURN A 0 IF NO BLOCK IS AVAILABLE |
| 659 | 659 | COPY FCB INFORMATION STARTING AT BYTE B FOR L BYTES INTO |
| 660 | 660 | BEGINNING OF CURRENTLY ADDRESSED DIRECTORY ENTRY |
| 669 | 669 | COPY THE ENTIRE FILE CONTROL BLOCK |
| 674 | 674 | RENAME THE FILE DESCRIBED BY THE FIRST HALF OF THE CURRENTLY |
| 675 | 675 | ADDRESSED FILE CONTROL BLOCK. THE NEW NAME IS CONTAINED IN THE |
| 676 | 676 | LAST HALF OF THE CURRENTLY ADDRESSED FILE CONTROL BLOCK. THE |
| 677 | 677 | FILE TYPE, FILE NAME, AND FILE EXT ARE CHANGED, BUT THE REEL |
| 678 | 678 | NUMBER FIELD IS IGNORED |
| 680 | 680 | SEARCH UP TO THE REEL NUMBER FIELD |
| 689 | 689 | SEARCH FOR DIRECTORY ENTRY, COPY TO FCB |
| 698 | 698 | LOCATE THE DIRECTORY ELEMENT AND RE-WRITE |
| 705 | 705 | CREATE A NEW FILE; FIRST CREATE ENTRY IN |
| 706 | 706 | THE DIRECTORY. FILE IS OPENED UPON RETURN |
| 710 | 710 | LOOK FOR AN EMPTY DIRECTORY ENTRY |
| 713 | 713 | SET ELEMENTS TO ZERO |
| 718 | 718 | COPY INTO DIRECTORY ENTRY |
| 725 | 725 | CLOSE CURRENT REEL AND OPEN THE HEXT ONE, IF POSSIBLE |
| 726 | 726 | READING IS TRUE IF WE ARE IN READ MODE |
| 728 | 728 | RET REMAINS AT 255 IF WE CANNOT OPEN THE NEXT REEL |
| 730 | 730 | INCREMENT THE REEL NUMBER |
| 739 | 739 | END OF FILE IN DISK READ |
| 757 | 757 | ERROR 2 IF READING UNWRITTTEN DATA |
| 760 | 760 | ARECORD IS NOW ACTUAL DISK ADDRESS |
| 762 | 762 | NOW READ THE BUFFER |
| 774 | 774 | PAST EOF, NEXT REEL NOT OPENED |
| 777 | 777 | NOT ALLOCATED |
| 778 | 778 | THE ARGUMENT TO GET$BLOCK IS THE STARTING POSITION |
| 779 | 779 | FOR THE DISK SEARCH - THIS SHOULD BE THE LAST 'ALLOCATED |
| 780 | 780 | BLOCK FOR THIS FILE, OR THE VALUE 0 IF NO SPACE HAS BEEN |
| 781 | 781 | ALLOCATED TO THIS FILE |
| 784 | 784 | THERE IS A PREVIOUS BLOCK ALLOCATED |
| 785 | 785 | NO MORE SPACE |
| 788 | 788 | BLOCK IS ALLOCATED |
| 792 | 792 | CONTINUE IF NO ERROR IN ALLOCATION |
| 798 | 798 | CHECK FOR END-OF-REEL, IF FOUND ATTEMPT TO OPEN |
| 799 | 799 | NEXT REEL IN PREPARATION FOR THE NEXT, WRITE |
| 802 | 802 | UPDATE CURRENT FCB BEFORE GOING TO THE NEXT REEL |
| 804 | 804 | VRECORD REMAINS AT MRC CAUSING END-OF-FILE |
| 805 | 805 | IF NO MORE DIRECTORY SPACE IS AVAILABLE |
| 806 | 806 | GOES TO ZERO |
| 815 | 815 | SELECT DISK 'INFO' FOR SUBSEQUENT |
| 816 | 816 | INPUT OR OUTPUT OPERATIONS |
| 818 | 818 | SELECTION ERROR |
| 819 | 819 | SELECT ERROR $ |
| 823 | 823 | NOTE THAT THIS ASSUMES THERE ARE NO MORE |
| 824 | 824 | THAN 8 DISKS ON THE SYSTEM - OTHERWISE |
| 825 | 825 | REPLACE BY .ALLOC0(SHL(DOUBLE(CURDSK), 5)) |
| 831 | 831 | SET CONTROLLER |
| 834 | 834 | CHECK TO INSURE THAT DISK IS LOGGED IN |
| 849 | 849 | CHECK CURRENT FCB TO SEE IF RESELECTION NECESSARY |
| 861 | 861 | ARRIVE HERE UPON ENTRY TO THE DISK MONITOR |
| 862 | 862 | SAVE THE STACKPOINTER, PERFORM THE DESIRED FUNCTION, |
| 863 | 863 | RESTORE THE STACKPOINTER, AND RETURN TO THE CALLING |
| 864 | 864 | PROGRAM. |
| 870 | 870 | CALLING PROGRAM'S STACK TOP ADDRESS NOW SAVED |
| 877 | 877 | 0: SYSTEM RE-BOOT |
| 879 | 879 | 1: READ CONSOLE |
| 880 | 880 | READ CHARACTER, TEST FOR GRAPHICS |
| 885 | 885 | 2: WRITE CONSOLE |
| 887 | 887 | 3: READ READER DEVICE |
| 899 | 899 | 9: PRINT BUFFER AT THE CONSOLE |
| 901 | 901 | 10: READ BUFFER FROM THE CONSOLE |
| 903 | 903 | 11: CHECK FOR CONSOLE INPUT READY |
| 905 | 905 | 12: |
| 907 | 907 | 13: RESET DISK SYSTEM, INITIALIZE TO DISK 0 |
| 915 | 915 | 15: OPEN |
| 919 | 919 | 16: CLOSE |
| 923 | 923 | 17: SEARCH FOR FIRST OCCURRENCE OF A FILE |
| 927 | 927 | 18: SEARCH FOR NEXT OCCURRENCE OF A FILE NAME |
| 951 | 951 | 24: RETURN THE LOGIN VECTOR |
| 953 | 953 | 25: RETURN SELECTED DISK NUMBER |
| 955 | 955 | 26: SET THE SUBSEQUENT DMA ADDRESS TO INFO |
| 957 | 957 | 27: RETURN THE LOGIN VECTOR ADDRESS |
| 959 | 959 | OF CASES |
| 962 | 962 | RESTORE DISK NUMBER |
| 965 | 965 | RESTORE THE USER'S STACK AREA |
| 968 | 968 | RETURN A SINGLE OR DOUBLE BYTE VALUE |
| 972 | 972 | TEN LOCATIONS IN RAM FOR THE INTERFACE |
